#include<stdlib.h>
#include<stdio.h>
#include<math.h>
#include<assert.h>
#include"Vecteur.h"


void afficheVecteur(vecteur v)
{
	printf("x : %d, y : %d, z : %d\n",v.x,v.y,v.z);
}

void directionVecteur(char direction, vecteur * v)
{
	
/* verification des precondition*/
	assert(direction=='h' || direction=='b' || direction=='d' || direction=='g' || direction=='a' || direction=='p');
	

	
	switch(direction)
	{
		case 'd' :
			v->x=1;
			v->y=0;
			v->z=0;
			break;
		case 'g' :
			v->x=-1;
			v->y=0;
			v->z=0;
			break;
		case 'a' :
			v->x=0;
			v->y=1;
			v->z=0;
			break;
		case 'p' :
			v->x=0;
			v->y=-1;
			v->z=0;
			break;
		case 'h' :
			v->x=0;
			v->y=0;
			v->z=1;
			break;
		case 'b' :
			v->x=0;
			v->y=0;
			v->z=-1;
			break;
	}
	
}

int modulo(int x, int y)
{
	int t;
	t=x/y;
	t=x-y*t;
	if(t<0)
	{
		return y+t;
	}
	else
	{
		return t;
	}
}

void changeSensVecteur(vecteur * v)
{
	vecteur t;
	
	t.x=0;
	t.y=0;
	t.z=0;
	
	soustraction(&t,v,v,0);
	
}

void addition(vecteur *  v1, vecteur * v2,vecteur *v3,int n)
{	
  if(n==0)
    {
      v3->x=(v1->x+v2->x);
      v3->y=(v1->y+v2->y);
      v3->z=(v1->z+v2->z);
    }
  else
    {
      v3->x=modulo((v1->x+v2->x),n);
      v3->y=modulo((v1->y+v2->y),n);
      v3->z=modulo((v1->z+v2->z),n);
    }
}

int getXVecteur(vecteur * vect)
{
	return vect->x;
}

int getYVecteur(vecteur * vect)
{
	return vect->y;
}

int getZVecteur(vecteur * vect)
{
	return vect->z;
}

void setXVecteur(vecteur * vect, int m)
{
	vect->x=m;
}

void setYVecteur(vecteur * vect, int m)
{
	vect->y=m;
}

void setZVecteur(vecteur * vect, int m)
{
	vect->z=m;
}


void soustraction(vecteur * v1, vecteur * v2, vecteur * v3, int n)
{
  if(n==0)
    {
      v3->x=(v1->x-v2->x);
      v3->y=(v1->y-v2->y);
      v3->z=(v1->z-v2->z);
    }
  else
    { 
      v3->x=modulo((v1->x-v2->x),n);
      v3->y=modulo((v1->y-v2->y),n);
      v3->z=modulo((v1->z-v2->z),n);
    }
}

void produit(vecteur * v1, int k, vecteur * v2, int n)
{
  if(n==0)
    {
      v2->x=(k*v1->x);
      v2->y=(k*v1->y);
      v2->z=(k*v1->z);
    }
  else
    {
      v2->x=modulo((k*v1->x),n);
      v2->y=modulo((k*v1->y),n);
      v2->z=modulo((k*v1->z),n);
    }
}

int compareVecteur(vecteur * v1, vecteur * v2)
{
	if(v1->x==v2->x && v2->y==v1->y && v1->z==v2->z)
	{
		return 1;
	}
	else{ return 0;}
}


char sensDirection(vecteur * v2,vecteur * v1,int n)
{
vecteur temp1,temp2;
	
/* Pour obtenir la direction du vecteur (v2-v1), on regarde quelle direction il faut ajouter a v1 pour obtenir v2 */
	directionVecteur('d',&temp1);
	addition(v1,&temp1,&temp2,n);
	if(compareVecteur(&temp2,v2)){return 'd';}
	
	directionVecteur('g',&temp1);
	addition(v1,&temp1,&temp2,n);
	if(compareVecteur(&temp2,v2)){return 'g';}
	
	directionVecteur('a',&temp1);
	addition(v1,&temp1,&temp2,n);
	if(compareVecteur(&temp2,v2)){return 'a';}
	
	directionVecteur('p',&temp1);
	addition(v1,&temp1,&temp2,n);
	if(compareVecteur(&temp2,v2)){return 'p';}
	
	directionVecteur('h',&temp1);
	addition(v1,&temp1,&temp2,n);
	if(compareVecteur(&temp2,v2)){return 'h';}
	
	directionVecteur('b',&temp1);
	addition(v1,&temp1,&temp2,n);
	if(compareVecteur(&temp2,v2)){return 'b';}
	else{return 0;}
	}

void remplaceVecteur(vecteur * v1, vecteur * v2)
{
	v1->x=v2->x;
	v1->y=v2->y;
	v1->z=v2->z;
}


void produitVectoriel(vecteur * v1,vecteur * v2,vecteur * v3)
{
  v3->x=(v1->y)*(v2->z)-(v1->z)*(v2->y);
  v3->y=(v1->z)*(v2->x)-(v1->x)*(v2->z);
  v3->z=(v1->x)*(v2->y)-(v1->y)*(v2->x);
}
